

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.PrintWriter;
import java.lang.Math;
import java.nio.charset.Charset;
import com.csvreader.CsvWriter;
import java.util.Calendar;

/**
 * Servlet implementation class egui_test
 */
public class Generate_Cases extends HttpServlet {
	private static final long serialVersionUID = 1L;
       
    /**
     * @see HttpServlet#HttpServlet()
     */
    public Generate_Cases() {
        super();
        // TODO Auto-generated constructor stub
    }

	/**
	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
	 */
    
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
		Calendar start = Calendar.getInstance();
		long starttime = start.getTimeInMillis();
		String Request = request.getParameter("Request");														//Parameter containing request for generation of test cases in stored in a parameter "Request"
		int count_elements = 0;																					//used for counting total number of elements
		try
		{
		int position = 0;
		int next_position=0;
		while( next_position != -1)
		{
			next_position = Request.indexOf("||", position+1);													//"||" is used as a tokenizer for separation of different elements
			position = next_position;
			count_elements++;																					//Total elements stored in the count_elements variable
		}
		String elements[] = new String[count_elements];															//Array for storing all elements
		position = 0;
		for(int i=0; i<count_elements-1; i++)
		{
			elements[i] = Request.substring(position+2, Request.indexOf("||", position+1));
			position = Request.indexOf("||", position+1);														//Elements being stored in the array
			
		}
		elements[count_elements-1] = Request.substring(position+2, Request.length());
		
		
		String elements_subparts[][] = new String[count_elements][10];											//Array for storing different parameters on a particular element like Range_From, Range_To, Isempty etc. "|" is used as a tokenizer.
		for(int i=0; i<count_elements; i++)
		{
			for(int j=0; j<10; j++)
				elements_subparts[i][j] = "\0";
			int sep_count = 0;
			int next_sep_position = 0;
			while(next_sep_position != -1)
			{
				next_sep_position = elements[i].indexOf("|", next_sep_position+1);
				sep_count++;
			}
			
			int sep_startPosition = -1;
			for(int k=0; k<sep_count-1; k++)
			{
				elements_subparts[i][k] = elements[i].substring(sep_startPosition+1, elements[i].indexOf("|", sep_startPosition+1));
				sep_startPosition = elements[i].indexOf("|", elements[i].indexOf("|", sep_startPosition+1));
				
			}
			elements_subparts[i][sep_count-1] = elements[i].substring(sep_startPosition+1, elements[i].length());
			
		}
																												// All the parameters of all elements are stored till here in a 2 dimentional array, elements_subparts[][].
		int max_testcases = 0;																					//Used for counting maximum possible cases for any element
		for(int i=0; i<count_elements; i++)
		{
			int cases = 0;																						//User for storing maximum possible cases for a particular element
			if(elements_subparts[i][1].equals("Textfield"))														//Condition for if aa element is of type Textfield
			{
				if(elements_subparts[i][2].equals("Integer"))													//If textfield is of type "Integer"
				{
					int Range_from = Integer.parseInt(elements_subparts[i][3]);									//Parameter Range_From for that particular variable 
					
					int Range_to = Integer.parseInt(elements_subparts[i][4]);									//Parameter Range_To for that particular variable 
					
					int isempty = Integer.parseInt(elements_subparts[i][5]);									//Parameter IsEmpty for that particular variable 
					
					cases = Range_to - Range_from + 1 + isempty;												//maximum possible cases for that particular element.
					if(cases > max_testcases)
						max_testcases = cases;																	//Checked if value of cases is greater than max_testcases. if it is so, then max_testcases is changed with the value of cases.
					
				}
				
				else if(elements_subparts[i][2].equals("Double"))												//If textfield is of type "Double"
				{
					Double Range_from = Double.parseDouble(elements_subparts[i][3]);							//Parameter Range_From for that particular variable
					Double Range_to = Double.parseDouble(elements_subparts[i][4]);								//Parameter Range_To for that particular variable
					int isempty = Integer.parseInt(elements_subparts[i][5]);									//Parameter IsEmpty for that particular variable
					Double DecimalPlaces = Double.parseDouble(elements_subparts[i][6]);							//Parameter DecimalPlaces used to store no of allowed possible digits after decimal.
					double local = (Range_to-Range_from)*Math.pow(10, DecimalPlaces);
					cases = (int)local + isempty + 1;															//maximum possible cases for that particular element.
					if(cases > max_testcases)
						max_testcases = cases;																	//Checked if value of cases is greater than max_testcases. if it is so, then max_testcases is changed with the value of cases.
					
				}
				
				else if(elements_subparts[i][2].equals("String"))												//If textfield is of type "String"
				{
					int Range_from = Integer.parseInt(elements_subparts[i][3]);									//Parameter Range_From for that particular variable
					int Range_to = Integer.parseInt(elements_subparts[i][4]);									//Parameter Range_To for that particular variable
					int isempty = Integer.parseInt(elements_subparts[i][5]);									//Parameter IsEmpty for that particular variable
					int onlyAlpha = Integer.parseInt(elements_subparts[i][6]);									//Parameter used to store if value of Only Alphabets is true or false
					int alphaSpecial = Integer.parseInt(elements_subparts[i][7]);								//Parameter used to store if value of Alphabets +Special Characters is true or false
					int alphaNum = Integer.parseInt(elements_subparts[i][8]);									//Parameter used to store if value of Only Alphanumeric is true or false
					int alphaNumSpl = Integer.parseInt(elements_subparts[i][9]);								//Parameter used to store if value of AlphaNumeric + SpecialCharacters is true or false
					
					int SwitchCase = 0;																			//Parameter SwitchCase is used to store the case depending upon the above 4 cases.
					if(alphaNumSpl==1)
						SwitchCase = 1;
					else if(alphaNumSpl==0 && alphaNum==1)
						SwitchCase = 2;
					else if(alphaNumSpl==0 && alphaNum==0 && alphaSpecial==1)
						SwitchCase = 3;
					else if(alphaNumSpl==0 && alphaNum==0 && alphaSpecial==0 && onlyAlpha==1)
						SwitchCase = 4;
					
						for(int r=Range_from; r<=Range_to; r++)
						{
							total =0;
							cases += buildWord(r, "", SwitchCase);												//buildword subroutine is used to calculate maximum no of cases possible for that particular case and particular length.
						}
						cases += isempty;
						if(cases > max_testcases)
							max_testcases = cases;																//Checked if value of cases is greater than max_testcases. if it is so, then max_testcases is changed with the value of cases.
						
				}
			}

			else if(elements_subparts[i][1].equals("Radio"))													//Condition for if aa element is of type Radio
			{
				int CommaPosition = 0;																			//Different values of possible values are separated using comma (,)
				int next_CommaPosition=0;
				int NoOfComma = 0;																				//Parameter used for storing number of all possible allowed values
				while( next_CommaPosition != -1)
				{
					next_CommaPosition = elements_subparts[i][2].indexOf(",", CommaPosition+1);
					CommaPosition = next_CommaPosition;
					NoOfComma++;																				//no of possible allowed values of radio calculated depending upon no of commas
				}
				
				if(NoOfComma > max_testcases)
					max_testcases = NoOfComma;																	//Checked if value of cases is greater than max_testcases. if it is so, then max_testcases is changed with the value of cases.
				
			}
			
			else if(elements_subparts[i][1].equals("SelectList"))												//Condition for if aa element is of type SelectList
			{
				int CommaPosition = 0;																			//Different values of possible values are separated using comma (,)
				int next_CommaPosition=0;
				int NoOfComma = 0;																				//Parameter used for storing number of all possible allowed values
				while( next_CommaPosition != -1)
				{
					next_CommaPosition = elements_subparts[i][2].indexOf(",", CommaPosition+1);
					CommaPosition = next_CommaPosition;
					NoOfComma++;																				//no of possible allowed values of radio calculated depending upon no of commas
				}
				
				if(NoOfComma > max_testcases)
					max_testcases = NoOfComma;																	//Checked if value of cases is greater than max_testcases. if it is so, then max_testcases is changed with the value of cases.
				
			}

			else if(elements_subparts[i][1].equals("CheckBox"))													//Condition for if aa element is of type SelectList
			{
				int CommaPosition = 0;																			//Parameter used for storing number of all possible allowed values
				int next_CommaPosition=0;															
				Integer NoOfComma = 0;
				while( next_CommaPosition != -1)
				{
					next_CommaPosition = elements_subparts[i][2].indexOf(",", CommaPosition+1);
					CommaPosition = next_CommaPosition;
					NoOfComma++;																				//no of possible allowed values of radio calculated depending upon no of commas
				}
				double totalPermutationCases = Math.pow(2, Double.parseDouble(NoOfComma.toString()));			//no of possible permutations of options depending upon the fact that if checkbox values are "yes" and "no" then allowed values will be "yes" , "no" and "yes & no both".
				int casestotal = (int)totalPermutationCases;
				if(casestotal > max_testcases)
					max_testcases = casestotal;																	//Checked if value of cases is greater than max_testcases. if it is so, then max_testcases is changed with the value of cases.
				
			}
		}

		String test_cases[][] = new String[count_elements][max_testcases+1];									//A two dimentional array used for storing all the possible test cases together.
		
		for(int i=0; i<count_elements; i++)
		{
			if(elements_subparts[i][1].equals("Textfield"))														// Condition for if a partical elements is of type Textfield
			{
				
				if(elements_subparts[i][2].equals("String"))													// Condition for if that particular textfield is of type String
				{
					int Range_from = Integer.parseInt(elements_subparts[i][3]);									//Parameter Range_From for that particular variable
					int Range_to = Integer.parseInt(elements_subparts[i][4]);									//Parameter Range_To for that particular variable
					int isempty = Integer.parseInt(elements_subparts[i][5]);									//Parameter IsEmpty for that particular variable
					int onlyAlpha = Integer.parseInt(elements_subparts[i][6]);									//Parameter used to store if value of Only Alphabets is true or false
					int alphaSpecial = Integer.parseInt(elements_subparts[i][7]);								//Parameter used to store if value of Alphabets + SpecialCharacters is true or false
					int alphaNum = Integer.parseInt(elements_subparts[i][8]);									//Parameter used to store if value of AlphaNumeric is true or false
					int alphaNumSpl = Integer.parseInt(elements_subparts[i][9]);								//Parameter used to store if value of AlphaNumeric + SpecialCharacters is true or false
					
					int SwitchCase = 0;																			//Parameter SwitchCase is used to store the case depending upon the above 4 cases.
					if(alphaNumSpl==1)
						SwitchCase = 1;
					else if(alphaNumSpl==0 && alphaNum==1)
						SwitchCase = 2;
					else if(alphaNumSpl==0 && alphaNum==0 && alphaSpecial==1)
						SwitchCase = 3;
					else if(alphaNumSpl==0 && alphaNum==0 && alphaSpecial==0 && onlyAlpha==1)
						SwitchCase = 4;
	
					strings =0;
					for(int r=Range_from; r<=Range_to; r++)
					{
						buildTestCase(r, "", SwitchCase, test_cases, i);										//buildTestCase subroutine is used for generating possible test cases based on the value of Switchcase, Range_From and Range_To. All the possible testcases are stored in the array test_cases[][] 
					}
					if(isempty == 1)
						test_cases[i][strings] = " ";															//Is value of IsEmpty is 1 then an additional value is added to the array i.e. "" (empty value).
					
				}

				else if(elements_subparts[i][2].equals("Integer"))												// Condition for if that particular textfield is of type integer
				{
					int Range_from = Integer.parseInt(elements_subparts[i][3]);									//Parameter Range_From for that particular variable
					int Range_to = Integer.parseInt(elements_subparts[i][4]);									//Parameter Range_To for that particular variable
					int isempty = Integer.parseInt(elements_subparts[i][5]);									//Parameter IsEmpty for that particular variable
					
					int cases = Range_to-Range_from+1+isempty;													//Total number of possible cases for that particular element
					
					if(isempty == 0)
						for(int r=0;r<cases;r++)
						{
							Integer numInString = Range_from+r;
							test_cases[i][r] = numInString.toString();											//All possible testcases are stored in the 2 dimnetional array test_cases[][]
						}
					else if(isempty == 1)
					{
						test_cases[i][0] = " ";																	//If value of isempty is 1 then an additional value "" (empty) is added to the array
						for(int r=0;r<cases-1;r++)
						{
							Integer numInString = Range_from+r;
							test_cases[i][r+1] = numInString.toString();
						}
					}
						
				}
				
				else if(elements_subparts[i][2].equals("Double"))												// Condition for if that particular textfield is of type Double								
				{
					Double Range_from = Double.parseDouble(elements_subparts[i][3]);							//Parameter Range_From for that particular variable
					Double Range_to = Double.parseDouble(elements_subparts[i][4]);								//Parameter Range_To for that particular variable
					int isempty = Integer.parseInt(elements_subparts[i][5]);									//Parameter IsEmpty for that particular variable
					Double DecimalPlaces = Double.parseDouble(elements_subparts[i][6]);							//Parameter used to store the number of allowed digits after decimal place
					double local = (Range_to-Range_from)*Math.pow(10, DecimalPlaces);
					int D_cases = (int)local + isempty + 1;														//Total possible cases for this particular element
					if(isempty == 0)
						for(int d=-1; d<D_cases-1; d++)
						{
							double value = ((Range_from)*Math.pow(10, DecimalPlaces)+1+d);
							Integer intValue = (int)value;
							Double dValue = intValue/Math.pow(10, DecimalPlaces);
							test_cases[i][d+1] = dValue.toString();												//All the testcases for this particular element is stored in the array
						}
					else if(isempty == 1)
					{
						test_cases[i][0] = " ";																	//If value of isempty is 1 then an additional value "" (empty value) is added to the array
						for(int d=-1; d<D_cases-2; d++)
						{
							double value = ((Range_from)*Math.pow(10, DecimalPlaces)+1+d);
							Integer intValue = (int)value;
							Double dValue = intValue/Math.pow(10, DecimalPlaces);
							test_cases[i][d+2] = dValue.toString();												//All the possible testcases are stored in the array
						}
					}
					
				}
			}
			else if(elements_subparts[i][1].equals("Radio"))													// Condition for if a partical elements is of type Radio
			{
				int CommaPosition = 0;
				int next_CommaPosition=0;
				Integer NoOfComma = 0;																			//Parameter used to calculate total no of allowed values. Allowed valued are separated by a comma (,)
				while( next_CommaPosition != -1)
				{
					next_CommaPosition = elements_subparts[i][2].indexOf(",", CommaPosition+1);
					CommaPosition = next_CommaPosition;
					NoOfComma++;																				//Total no of possible values are stored in the variable
				}
				int Cposition = 0;
				for(int p=0; p<NoOfComma-1; p++)
				{
					test_cases[i][p] = elements_subparts[i][2].substring(Cposition, elements_subparts[i][2].indexOf(",", Cposition+1));
					Cposition = elements_subparts[i][2].indexOf(",", Cposition+1)+1;							//All the testcases are stored in the 2 dimentional array, test_cases[][]
					
				}
				
				test_cases[i][NoOfComma-1] = elements_subparts[i][2].substring(Cposition, elements_subparts[i][2].length());
						
			}
			
			else if(elements_subparts[i][1].equals("CheckBox"))													// Condition for if a partical elements is of type CheckBox
			{
				int CommaPosition = 0;
				int next_CommaPosition=0;
				Integer NoOfComma = 0;																			//Parameter used to calculate total no of allowed values. Allowed valued are separated by a comma (,)
				while( next_CommaPosition != -1)
				{
					next_CommaPosition = elements_subparts[i][2].indexOf(",", CommaPosition+1);
					CommaPosition = next_CommaPosition;
					NoOfComma++;																				//Total no of possible values are stored in the variable
				}
				
				String[] total_choices = new String[NoOfComma];
				int Comma = 0;
				for(int c=0; c<NoOfComma-1; c++)
				{
					total_choices[c] = elements_subparts[i][2].substring(Comma, elements_subparts[i][2].indexOf(",", Comma+1));
					Comma = elements_subparts[i][2].indexOf(",", Comma+1)+1;
				}
				total_choices[NoOfComma-1] = elements_subparts[i][2].substring(Comma, elements_subparts[i][2].length());

				String compulsaryElements = elements_subparts[i][3];
				compulsaryElements = compulsaryElements.replace(',', '|');
				System.out.println(compulsaryElements);
				if(!elements_subparts[i][2].equals("~"))
				{
					choices = 0;
					for(int c=0;c<=NoOfComma;c++)
					{
						gen_case(total_choices, c, test_cases, i, compulsaryElements);													//gen_case subroutine is used for generating all the possible permutations of the allowed values. If allowed values are "yes" and "no", then possible testcases will be "yes", "no" and "yes & no both".
					}
				}
				else if(elements_subparts[i][2].equals("~")&&!compulsaryElements.equals("~"))
					test_cases[i][0] = compulsaryElements;
				else if(elements_subparts[i][2].equals("~")&&compulsaryElements.equals("~"))
					test_cases[i][0] = "\0";
			}
			
			else if(elements_subparts[i][1].equals("SelectList"))												// Condition for if a partical elements is of type SelectList
			{
				int CommaPosition = 0;
				int next_CommaPosition=0;
				Integer NoOfComma = 0;																			//Parameter used to calculate total no of allowed values. Allowed valued are separated by a comma (,)
				while( next_CommaPosition != -1)
				{
					next_CommaPosition = elements_subparts[i][2].indexOf(",", CommaPosition+1);
					CommaPosition = next_CommaPosition;
					NoOfComma++;																				//Total no of possible values are stored in the variable
				}
				int Cposition = 0;
				for(int p=0; p<NoOfComma-1; p++)
				{
					test_cases[i][p] = elements_subparts[i][2].substring(Cposition, elements_subparts[i][2].indexOf(",", Cposition+1));
					Cposition = elements_subparts[i][2].indexOf(",", Cposition+1)+1;
					
				}
				
				test_cases[i][NoOfComma-1] = elements_subparts[i][2].substring(Cposition, elements_subparts[i][2].length());		//All the possible testcases are stored in the 2 dimentional array test_cases[][]
				
				
			}		
		
		}

		response.setContentType("text");
		response.setHeader("Content-Disposition", "attachment; filename=sampleName.csv");
		CsvWriter wt= new CsvWriter(response.getOutputStream(),',', Charset.defaultCharset());

		String[] record = new String[elements_subparts.length];
		for(int q=0;q<elements_subparts.length;q++)
		{
			record[q] = elements_subparts[q][0] + "(" + elements_subparts[q][1] + ")";
		}
		wt.writeRecord(record);
		
		recurse("", test_cases, 0, wt, elements_subparts.length);
		
		wt.close();
		Calendar end = Calendar.getInstance();
		long endtime = end.getTimeInMillis();
		System.out.println("Time Taken "+ (endtime-starttime));
		}

		catch(Exception ex)
		{
		}
	}
	
	static int total;
	public static int buildWord(int remaining, String word, int switchcase)										//buildword subroutine. Returns no of possible words for any particular length and value of switchcase.
	  {
	    if (remaining == 0)
	    {
	      total++;
	    }
	    else
	    {
	    	if(switchcase == 1)																					//case when only alphanumeric + special charaters are allowed
	    	{
		  	      for (char letter = '!'; letter<='z' ; ++letter)
			      {
			        if((letter>='!' && letter<= '\'') || (letter>='0' && letter<= '9') || (letter>='a' && letter <= 'z'))
			                buildWord(remaining-1, word + letter, 1);
			      }	    		
	    	}
	    	else if(switchcase == 2)																			//case when alphanumeric values are allowed
	    	{
		  	      for (char letter = '0'; letter<='z' ; ++letter)
			      {
			        if((letter>='0' && letter<= '9') || (letter>='a' && letter <= 'z'))
			                buildWord(remaining-1, word + letter, 2);
			      }	    		
	    	}
	    	else if(switchcase == 3)																			//case when alphabets + specialcharacters are allowed
	    	{
		  	      for (char letter = '!'; letter<='z' ; ++letter)
			      {
			        if((letter>='!' && letter<= '\'') || (letter>='a' && letter <= 'z'))
			                buildWord(remaining-1, word + letter, 3);
			      }	    		
	    	}
	    	else if(switchcase == 4)																			//case when only alphabets is allowed
	    	{
		  	      for (char letter = 'a'; letter<='z' ; ++letter)
			      {
			        if((letter>='a' && letter <= 'z'))
			                buildWord(remaining-1, word + letter, 4);
			      }	    		
	    	}
	    }
	    return total;
	  }


	static int strings;
	public static int buildTestCase(int remaining, String word, int switchcase, String array[][], int column)	//buildtestcases subroutine. Array test_cases[][] is passed as a argument and all the possible testcases are generated and stored in this array for final generation of testcases.
	  {
	    if (remaining == 0)
	    {
	    	array[column][strings++] = word;
	    }
	    else
	    {
	    	if(switchcase == 1)																					//case when alphanumeric + specialCharacters are allowed
	    	{
		  	      for (char letter = '!'; letter<='z' ; ++letter)												
			      {
			        if((letter>='!' && letter<= '\'') || (letter>='0' && letter<= '9') || (letter>='a' && letter <= 'z'))
			                buildTestCase(remaining-1, word + letter, 1, array, column);
			      }	    		
	    	}
	    	else if(switchcase == 2)																			//case when only alphanumeric values are allowed
	    	{
		  	      for (char letter = '0'; letter<='z' ; ++letter)
			      {
			        if((letter>='0' && letter<= '9') || (letter>='a' && letter <= 'z'))
			                buildTestCase(remaining-1, word + letter, 2, array, column);
			      }	    		
	    	}
	    	else if(switchcase == 3)																			//case when alphabets and special characters are allowed
	    	{
		  	      for (char letter = '!'; letter<='z' ; ++letter)
			      {
			        if((letter>='!' && letter<= '\'') || (letter>='a' && letter <= 'z'))
			        		buildTestCase(remaining-1, word + letter, 3, array, column);
			      }	    		
	    	}
	    	else if(switchcase == 4)																			//case when only alphabets are allowed
	    	{
		  	      for (char letter = 'a'; letter<='z' ; ++letter)
			      {
			        if((letter>='a' && letter <= 'z'))
			        		buildTestCase(remaining-1, word + letter, 4, array, column);
			      }	    		
	    	}
	    }
	    return 1;
	  }
static int choices;
public static void gen_case(String elements[], int no_of_choices, String array[][], int column, String compulsaryElement){				//subroutine gen_case. returns all the possible permutations for values of checkboxes.
	int[] indices;
	CombinationGenerator x = new CombinationGenerator (elements.length, no_of_choices);							//x is an object of class CombinationGenerator.
	StringBuffer combination;
	while (x.hasMore ()) {
	  combination = new StringBuffer ();
	  indices = x.getNext ();
	  for (int i = 0; i < indices.length; i++) {
	    combination.append ('|'+elements[indices[i]]);
	  }
	  if(!compulsaryElement.equals("~"))
	  {
		  if(no_of_choices != 0)
			  array[column][choices++] = combination.toString().substring(1, combination.toString().length())+ "|" + compulsaryElement;
		  else
			  array[column][choices++] = compulsaryElement;
	  }
	  else if(compulsaryElement.equals("~"))
	  {
		  if(no_of_choices != 0)
			  array[column][choices++] = combination.toString().substring(1, combination.toString().length());
		  else
			  array[column][choices++] = combination.toString();
	  
	  }
	}
}

public static void recurse (String s, String[][] arrs, int k, CsvWriter wt, int column ) {														//recurse subroutine. Used for generation of combined testcases for all the elements. Values for different elements is separated by a comma. The array test_cases[][] is passed as a argument to this function and testcases are generated using values stored in different rows for different element.
    try
    {
	String[] record = new String[column];
	if (k == arrs.length) {
        s=s.substring(1, s.length());
		int CPosition = 0;
		int nextCommaPosition = 0;
		for(int i=0;i<column-1;i++)
		{
			nextCommaPosition = s.indexOf(",", CPosition);
			record[i] = s.substring(CPosition, nextCommaPosition);
			CPosition = nextCommaPosition+1;
		}
		record[column-1]  = s.substring(CPosition, s.length());
		wt.writeRecord(record);
		
    } else {
        for (String o : arrs[k]) {
        	if(o!=null)
            recurse(s +','+ o, arrs, k + 1,  wt, column);
        }
    }
    }
    catch(Exception ex)
    {
    	
    }
    return;
}
	/**
	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
	 */
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		// TODO Auto-generated method stub
	}

}
